package com.wangp.mywrite.inwork.pattern._10;

import com.google.common.collect.ImmutableList;
import com.wangp.mywrite.inwork.pattern.InitData;
import java.util.List;
import org.apache.commons.lang3.StringEscapeUtils;
import org.unbescape.css.CssStringEscapeLevel;

/***
 * @author wangpeng
 * @since 2022-03-04  11:09
 */
public class Example {


    public static void main(String[] args) {
//        example1();
//        example2();
//        example3();
//        example4();
//        example5();
        example6();
    }

    /**
     * <p> B.1 北美电话号码 </p>
     * <p> North American Numbering Plan（北美编号方案）对北美地区的电话号码格式做出了定义。</p>
     * <p> 根据这一方案，北美地区（美国、加拿大、加勒比海地区大部以及其他几个地区）的电话号码由一个3位数的区号和一个7位数的号码构成（这7位数字又分成一个3位数的局号和一个4位数的线路号，局号和线路号之间用连字符分隔）。</p>
     * <p> 每位电话号码可以是任意数字，但区号和局号的第一位数字不能是0或1。</p>
     * <p> 在书写电话号码的时候，人们往往把区号放在括号里，而且还往往会在区号与实际电话号码之间加上一个连字符来分隔它们。</p>
     * <p> 匹配（555）555-5555（右括号的后面有一个空格）或（555）555-5555或555-555-5555其中之一很简单，但要想编写一个能够同时匹配这些电话号码的模式就不那么容易</p>
     */
    private static void example1() {
        String phoneReg = "((\\([2-9]\\d{2}\\))|([2-9]\\d{2}\\-))\\s*([2-9]\\d{2}\\-)\\d{4}";
        System.out.println(InitData.filterByRegexPattern(InitData.NA_PHONE_LIST, phoneReg));

        // 书本上的
        String benReg = "\\(?[2-9]\\d\\d\\)?[ -]?[2-9]\\d\\d-\\d{4}";
        System.out.println(InitData.filterByRegexPattern(InitData.NA_PHONE_LIST, benReg));
    }


    /**
     * IP 地址正则表达式
     */
    private static void example2() {
        String ipReg = "(((\\d{1,2})|(2[0-4]\\d)|(25[0-5]))\\.){3}((\\d{1,2})|(2[0-4]\\d)|(25[0-5]))";
        System.out.println(InitData.filterByRegexPattern(InitData.IP_LIST, ipReg));
    }

    /**
     * 邮箱正则
     */
    private static void example3() {
        String emailReg = "(\\w+\\.)*\\w+@(\\w+.)+[A-Za-z]+";
        System.out.println(InitData.filterByRegexPattern(InitData.EMAIL_LIST, emailReg));
    }


    /***
     * 这是第一行
     * 这是第二行
     * 这是第三行
     *
     * 这是第四行
     */
    private static void example4() {
        // 给此方法的 javadoc 注释加上 <p></p>
        String pReg = "(?<=\\*)([^*/\\n\\r])(\\s*.*)";
        String content = "    /***\n"
                + "     * 这是第一行\n"
                + "     * 这是第二行\n"
                + "     * 这是第三行\n"
                + "     *\n"
                + "     * 这是第四行\n"
                + "     */";
        String replace = "<p>$2</p>";
        System.out.println(InitData.replaceByReg(content, pReg, replace));
    }


    private static void example5() {
        // 结果：abc def-abc-def
        //     |--$0--||$1||$2|
        System.out.println("abc def".replaceFirst("(\\w+)\\s+(\\w+)", "$0-$1-$2"));
        // abc def-abc-def aaa bbb-aaa-bbb
        System.out.println("abc def aaa bbb".replaceAll("(\\w+)\\s+(\\w+)", "$0-$1-$2"));

        // 去除重复出现 helllo -> hello
        String hello = "helllo";
        System.out.println(hello.replaceAll("(.)\\1+", "$1$1"));
        // $0 = lll
        System.out.println(hello.replaceAll("(.)\\1+", "$0$1"));
        // AABB -> AB
        String aabb = "AABB";
        // AB
        System.out.println(aabb.replaceFirst("(.)\\1(.)\\2", "$1$2"));
        // $0 = AABB
        System.out.println(aabb.replaceFirst("(.)\\1(.)\\2", "$0$1"));
    }

    private static void example6() {
        ImmutableList<String> list = ImmutableList.<String>builder()
                .add("1.Windows98")
                .add("2.Windows2000")
                .add("3.WindowsNT")
                .add("4.Windows3.1")

                .add("98Windows.1")
                .add("2000Windows.2")
                .add("NTWindows.3")
                .add("3.1Windows.4")
                .build();

        // 等价于 "(.*)((Windows98)|(Windows2000))"
        String containReg = "(.*)(Windows)(?:98|2000)";
        // [1.Windows98, 2.Windows2000]
        System.out.println(InitData.find(list, containReg));

        String lookahead = "(.*)Windows(?=98|2000)";
        // [1.Windows, 2.Windows]
        System.out.println(InitData.find(list, lookahead));
        String noLookahead = "(.*)Windows(?!98|2000)";
        // [3.Windows, 4.Windows, 98Windows, 2000Windows, NTWindows, 3.1Windows]
        System.out.println(InitData.find(list, noLookahead));

        String lookbehind = "(?<=98|2000)(Windows)(.*)";
        // [Windows.1, Windows.2]
        System.out.println(InitData.find(list, lookbehind));
        String noLookbehind = "(?<!98|2000)(Windows)(.*)";
        // [Windows98, Windows2000, WindowsNT, Windows3.1, Windows.3, Windows.4]
        System.out.println(InitData.find(list, noLookbehind));
    }
}
